<exampleAINetIterface>

	<inputSummary>
		Add 0 or more nodes. Change any numbers in any nodes (within certain limits).
		Run the network's main execute function, which may leave the network in a stable state or not.
		The main function does nothing if the network is in a stable state.
		Adding nodes or changing numbers usually puts the network in an unstable state.
		If the network state is stable or not is deterministic and the measure of that never changes.
	</inputSummary>
	
	/** Childs of this node */
	public Node c[];
	
	/** Child count. Ignore higher array indexs */
	public int cSize;
	
	/** Weights or other data in this node */
	public double d[];
	
	/** How many doubles to use in the array. Ignore higher array indexs */
	public int dSize;
	
	/** When a Node is changed enough that the sorted order of this Net's Nodes would change,
	it is added to this Set and sorted later. Until then, the only way to know the
	first Node is to find the highest valued Node in this Set.
	When the other list/array of Nodes is sorted, this Set should be cleared and
	only the first few Nodes in that list/array added to this Set.
	When this Set gets too big, do that again.
	This Set must always contain the highest scoring Node,
	so if the highest scoring 20 Nodes are put in this Set after every sort,
	this Set can be used at most 20 times before the next sort,
	but that is not enough because all Nodes in this Set may quickly start scoring low
	which would require the 21st Node be brought into this Set
	therefore a minimum score must be kept and if all Nodes in this Set score below it
	then a new sort must be done.
	*/
	public Set<Node> possiblyActiveNodes;
	
	/** Before each cycle of the Net, if all Nodes in the possiblyActiveNodes Set score below this,
	a higher scoring Node must be put in that Set. An easy way to do that is to do the whole sorting.
	When updating nodes (like firing 1 Node in a neural network and updating its childs too),
	Nodes with scores at least this high must be put in the Set, but putting other Nodes in the Set is optional.
	Low scoring Nodes are allowed in the Set because their score may decrease while they're in the Set.
	*/
	public double minActiveScore;

	<sizeLimits>
		nodeChildsSizeMin and nodeChildsSizeMax are public ints
	</sizeLimits>
	
	<addDeleteEtc>
		netAction, nodeAction, nodeAdd, nodeDelete, nodeChildAdd, and nodeChildDelete
		are all functions of 1 Node where that Node contains all Node parameters for the function to use.
	</addDeleteEtc>
	
	
</exampleAINetIterface>